package solution.medium;

import com.alibaba.fastjson2.JSONObject;
import suport.ListNode;

import java.sql.SQLOutput;
import java.util.ArrayList;

public class 一百以内 {

    public static void main(String[] args) {
        //2
        //    给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
        //    请你将两个数相加，并以相同形式返回一个表示和的链表。
        //    你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
        ListNode listNode1 = new ListNode(2,new ListNode(4,new ListNode(3)));
        ListNode listNode2 = new ListNode(5,new ListNode(6,new ListNode(4)));
        ListNode listNode = Solution_2.addTwoNumbers(listNode1, listNode2);
        System.out.println("2:"+ JSONObject.toJSONString(listNode));
        //3
        /*    给定一个字符串 s ，请你找出其中不含有重复字符的 最长
    子串
    的长度。
    示例 1:

    输入: s = "abcabcbb"
    输出: 3
    解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。*/
        int result3 = Solution_3.lengthOfLongestSubstring("abcabcbb");
        System.out.println(result3);

/*      6题
        将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

        比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：

        P   A   H   N
        A P L S I I G
        Y   I   R
        之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。

        请你实现这个将字符串进行指定行数变换的函数：*/
        String paypalishiring = Solution_6.convert("PAYPALISHIRING", 3);
        System.out.println(paypalishiring);

/*      7  给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

        如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

        假设环境不允许存储 64 位整数（有符号或无符号）。*/
        int reverse = Solution_7.reverse(123);
        System.out.println(reverse);



/*        8. 字符串转换整数 (atoi)
        中等
                相关标签
        相关企业
        请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数。

        函数 myAtoi(string s) 的算法如下：

        空格：读入字符串并丢弃无用的前导空格（" "）
        符号：检查下一个字符（假设还未到字符末尾）为 '-' 还是 '+'。如果两者都不存在，则假定结果为正。
        转换：通过跳过前置零来读取该整数，直到遇到非数字字符或到达字符串的结尾。如果没有读取数字，则结果为0。
        舍入：如果整数数超过 32 位有符号整数范围 [−231,  231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被舍入为 −231 ，大于 231 − 1 的整数应该被舍入为 231 − 1 。
        返回整数作为最终结果。*/


/*      11  给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

        找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

        返回容器可以储存的最大水量。

        说明：你不能倾斜容器。*/
        int a [] = {1, 8, 6, 2, 5, 4, 8, 3, 7};
        int i = Solution_11_1.maxArea(a);
        System.out.println("11:"+i);


    }



    static class Solution_2 {
        public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {

            int temp = 0;
            ListNode result = null;
            ListNode tempNode = null;
            while(l1!=null || l2!=null){
                // 记录当前节点的数据，第一次进来就为个位数据
                int v1 = 0;
                int v2 = 0;

                if(l1 != null){
                    v1 = l1.val;
                    l1 = l1.next;
                }
                if(l2 != null){
                    v2 = l2.val;
                    l2 = l2.next;
                }

                // temp用来保存进位
                // 当前节点数据和为sum
                int sum = temp+v1+v2;
                temp = sum/10;
                // 新链表的节点数据
                int nodeVal = sum%10;

                if (result == null){
                    result = new ListNode(nodeVal);
                    tempNode = result;
                }else{
                    tempNode.next = new ListNode(nodeVal);
                    tempNode = tempNode.next;
                }

            }
            if(temp != 0){
                tempNode.next = new ListNode(temp);
            }
            return result;
        }
    }



    static class Solution_3 {
        public static int lengthOfLongestSubstring(String s) {
            int charsHash[] = new int[1000];
            if (s.length() < 1) {
                return 0;
            }
            int i = 0;
            int j = 1;
            int max = 1;
            charsHash[(int) s.charAt(0)] = 1;
            while (j < s.length()) {
                // 判断是否存在重复字符
                if (charsHash[(int) s.charAt(j)] == 1) {
                    // 左指针移到该字符的下一个位置
                    while (s.charAt(j) != s.charAt(i)) {
                        charsHash[(int)s.charAt(i)] = 0;
                        i++;
                    }
                    // 相等后再移一位
                    charsHash[s.charAt(i)] = 0;
                    i++;

                }
                // 计算当前长度
                int tempLen = j - i + 1;
                if (tempLen > max) {
                    max = tempLen;
                }
                // 右指针移位
                charsHash[s.charAt(j)] = 1;
                j++;
            }
            return max;

        }
    }

    static class Solution_6 {
        public static String convert(String s, int numRows) {
            if (numRows<2){
                return s;
            }
            StringBuilder result = new StringBuilder();
            ArrayList<StringBuilder> rows = new ArrayList<>();
            for (int i = 0 ; i <numRows ;i++){
                rows.add(new StringBuilder());
            }
            boolean flag = true;
            int index = 0;
            for (int i = 0 ; i <s.length() ; i++){
                rows.get(index).append(s.charAt(i));
                if (index == 0 || index == numRows-1){
                    if (i!=0){
                        flag=!flag;
                    }
                }
                if (flag){
                    index++;
                }else {
                    index--;
                }
            }
            for(StringBuilder sb:rows){
                result.append(sb);
            }
            return  result.toString();
        }
    }

    static class Solution_7 {
        public static int reverse(int x) {
            try {
                if (x < 0) {
                    x = Math.abs(x);
                    String s = String.valueOf(x);
                    String string = new StringBuilder(s).reverse().toString();
                    int v = Integer.valueOf(string);
                    return -v;
                } else {
                    String s = String.valueOf(x);
                    String string = new StringBuilder(s).reverse().toString();
                    return Integer.valueOf(string);
                }
            } catch (Exception e) {
                return 0;
            }
        }
    }

    static class Solution_8 {
        public static int myAtoi(String s) {
            return 0;
        }
    }


    static class Solution_11 {
        public static int maxArea(int[] height) {
            int left = 0 ;
            int right= height.length-1;
            int leftHighMax = height[0];
            int rightHighMax = height[height.length-1];
            int max = 0;

            while (left<right){
                if (height[left] <= height[right]){
                    max = Math.max(max,(right-left)*height[left]);
                    if (left+1 < height.length-1 && height[left+1]<=leftHighMax){
                        while ( left+1 < height.length-1 && height[left+1]<=leftHighMax && left<right){
                            left++;
                        }
                    }else {
                        left++;
                    }
                    leftHighMax = height[left];
                }else {
                    max = Math.max(max,(right-left)*height[right]);
                    if (right-1>0 && height[right-1]<=rightHighMax){
                        while (right-1>0 && height[right-1]<=rightHighMax && left<right) {
                            right--;
                        }
                    }else {
                        right--;
                    }
                    rightHighMax = height[right];
                }
            }
            return max;
        }
    }
    //常规解法
    static class Solution_11_1 {
        public static int maxArea(int[] height) {
            int left = 0 ;
            int right= height.length-1;
            int max = 0;
            while (left<right){
                if (height[left] <= height[right]){
                    max = Math.max(max,(right-left)*height[left]);
                    left++;
                }else {
                    max = Math.max(max,(right-left)*height[right]);
                    right--;
                }
            }
            return max;
        }
    }
}
